package showtime.framework.utils{
	
	import flash.utils.ByteArray;
	/**
	 * 
	 * @author yinhao
	 * 
	 */	
	public class StringUtility{
		
		static public const chars:Array = ['零','壹','贰','叁','肆','伍','陆','柒','捌','玖','拾'];
		
		// Ignore case, to judge is equals.
		public static function equalsIgnoreCase(char1:String, char2:String):Boolean
		{
			return char1.toLowerCase() == char2.toLowerCase();
		}
		
		/**
		 * Get the length of String bytes, note that by the specified charset.
		 * @param value
		 * @param charSet
		 * @return 
		 * 
		 */		
		public static function getStringLengthByByte( value:String, charSet:String = "gb2312" ):int
		{
			var bytes:ByteArray = new ByteArray();
			
			bytes.writeMultiByte( value, charSet );			
			bytes.position = 0;
			
			return bytes.length;
		}
		
		/**
		 * Cvonert Arabic numbers to chinese char.
		 * 
		 * @param value
		 * 
		 */		
		public static function convertToChinese(value:int):String
		{
			return chars[value];
		}
		
		/**
		 * Get file name.
		 * 
		 * @param path
		 * @return 
		 * 
		 */			
		public static function filePathToFileName(path:String):String
		{
			path = path.slice(path.lastIndexOf("/") + 1);
			path = path.slice(0, path.indexOf("."));
			
			return path;
		}
		
		
		
		public static function filePathToFileExt(path:String):String
		{
			path = path.slice(path.lastIndexOf(".") + 1);
			
			return path;
		}
		
		// Judge is equals with each other.
		public static function equals(char1:String,char2:String):Boolean
		{
			return char1 == char2;
		}
		
		//--------------------------------------------------------------------------
		//
		// Is valid email adress..
		//
		// @param char
		//--------------------------------------------------------------------------
		public static function isEmail(char:String):Boolean
		{
			if(char == null)
			{
				return false;
			}
			
			char = trim(char);
			
			var pattern:RegExp = /(\w|[_.\-])+@((\w|-)+\.)+\w{2,4}+/; 
			
			var result:Object = pattern.exec(char);
			
			if (result == null) 
			{
				return false;
			}
			
			return true;
		}
		
		//是否是数值字符串;
		public static function isNumber(char:String):Boolean
		{
			if(char == null)
			{
				
				return false;
			}
			
			return !isNaN(Number(char));
		}
		
		//是否为Double型数据;
		public static function isDouble(char:String):Boolean
		{
			char = trim(char);
			
			var pattern:RegExp = /^[-\+]?\d+(\.\d+)?$/; 
			
			var result:Object = pattern.exec(char);
			if (result == null) 
			{
				return false;
			}
			
			return true;
		}
		
		/**
		 * Is http format protocol.  
		 * @param char
		 * @return 
		 * 
		 */		
		public static function isHTTP(char:String):Boolean
		{
			return char.substr(0,7).toLowerCase() == "http://";
		}
		
		//Integer;
		public static function isInteger(char:String):Boolean
		{
			if (char == null){
				
				return false;
			}
			char = trim(char);
			
			var pattern:RegExp = /^[-\+]?\d+$/; 
			
			var result:Object = pattern.exec(char);
			
			if(result == null) 
			{
				return false;
			}
			
			return true;
		}
		
		//English;
		public static function isEnglish(char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			
			char = trim(char);
			var pattern:RegExp = /^[A-Za-z]+$/; 
			
			var result:Object = pattern.exec(char);
			
			if (result == null) 
			{
				return false;
			}
			return true;
		}
		//中文;
		public static function isChinese(char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char = trim(char);
			var pattern:RegExp = /^[\u0391-\uFFE5]+$/; 
			var result:Object = pattern.exec(char);
			if (result == null) 
			{
				return false;
			}
			return true;
		}
		//双字节
		public static function isDoubleChar(char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char = trim(char);
			var pattern:RegExp = /^[^\x00-\xff]+$/; 
			var result:Object = pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}
		
		//含有中文字符
		public static function hasChineseChar(char:String):Boolean
		{
			if(char == null)
			{
				return false;
			}
			char = trim(char);
			var pattern:RegExp = /[^\x00-\xff]/; 
			var result:Object = pattern.exec(char);
			if (result == null)
			{
				return false;
			}
			return true;
		}
		//注册字符;
		public static function hasAccountChar(char:String,len:uint=15):Boolean
		{
			if(char == null){
				return false;
			}
			
			if (len < 10)
			{
				len = 15;
			}
			char = trim(char);
			
			var pattern:RegExp = new RegExp("^[a-zA-Z0-9][a-zA-Z0-9_-]{0,"+len+"}$", ""); 
			var result:Object = pattern.exec(char);
			if (result == null) 
			{
				return false;
			}
			return true;
		}
		//URL地址;
		public static function isURL(char:String):Boolean
		{
			if (char == null)
			{
				return false;
			}
			char = trim(char).toLowerCase();
			
			var pattern:RegExp = /^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/; 
			var result:Object = pattern.exec(char);
			if (result == null) 
			{
				return false;
			}
			return true;
		}
		
		// 是否为空白;		
		public static function isWhitespace(char:String):Boolean
		{
			switch (char)
			{
				case "":
				case " ":
				case "\t":
				case "\r":
				case "\n":
				case "\f":
					return true;	
				default:
					return false;
			}
		}
		
		//去左右空格;
		public static function trim(char:String):String
		{
			if (char == null)
			{
				return null;
			}
			
			return rtrim(ltrim(char));
		}
		
		//去左空格; 
		public static function ltrim(char:String):String
		{
			if(char == null)
			{
				return null;
			}
			var pattern:RegExp = /^\s*/; 
			
			return char.replace(pattern,"");
		}
		
		//去右空格;
		public static function rtrim(char:String):String
		{
			if (char == null)
			{
				return null;
			}
			var pattern:RegExp = /\s*$/; 
			
			return char.replace(pattern,"");
		}
		
		//是否为前缀字符串;
		public static function beginsWith(char:String, prefix:String):Boolean
		{			
			return (prefix == char.substring(0, prefix.length));
		}
		
		//是否为后缀字符串;
		public static function endsWith(char:String, suffix:String):Boolean
		{
			return (suffix == char.substring(char.length - suffix.length));
		}
		
		//去除指定字符串;
		public static function remove(char:String,remove:String):String
		{
			return replace(char,remove,"");
		}
		
		//字符串替换;
		public static function replace(char:String, replace:String, replaceWith:String):String
		{			
			return char.split(replace).join(replaceWith);
		}
		
		//utf16转utf8编码;
		public static function utf16to8(char:String):String
		{
			var out:Array = new Array();
			
			var len:uint = char.length;
			
			for(var i:uint=0; i < len; i++)
			{
				var c:int = char.charCodeAt(i);
				
				if(c >= 0x0001 && c <= 0x007F)
				{
					out[i] = char.charAt(i);
				} 
				else if (c > 0x07FF)
				{
					out[i] = String.fromCharCode(0xE0 | ((c >> 12) & 0x0F),
						0x80 | ((c >>  6) & 0x3F),
						0x80 | ((c >>  0) & 0x3F));
				}
				else 
				{
					out[i] = String.fromCharCode(0xC0 | ((c >>  6) & 0x1F),
						0x80 | ((c >>  0) & 0x3F));
				}
			}
			return out.join('');
		}
		
		//utf8转utf16编码;
		public static function utf8to16(char:String):String
		{
			var out:Array = new Array();
			var len:uint = char.length;
			var i:uint = 0;
			var char2:int,char3:int;
			
			while(i<len)
			{
				var c:int = char.charCodeAt(i++);
				switch(c >> 4)
				{
					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
						// 0xxxxxxx
						out[out.length] = char.charAt(i-1);
						break;
					case 12: case 13:
						// 110x xxxx   10xx xxxx
						char2 = char.charCodeAt(i++);
						out[out.length] = String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
						break;
					case 14:
						// 1110 xxxx  10xx xxxx  10xx xxxx
						char2 = char.charCodeAt(i++);
						char3 = char.charCodeAt(i++);
						out[out.length] = String.fromCharCode(((c & 0x0F) << 12) |
							((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0));
						break;
				}
			}
			
			return out.join('');
		}
		
		//转换字符编码;
		public static function encodeCharset(char:String,charset:String):String
		{
			var bytes:ByteArray = new ByteArray();
			bytes.writeUTFBytes(char);
			bytes.position = 0;
			return bytes.readMultiByte(bytes.length, charset);
		}
		
		//添加新字符到指定位置;		
		public static function addAt(char:String, value:String, position:int):String 
		{
			if (position > char.length)
			{
				position = char.length;
			}
			var firstPart:String = char.substring(0, position);
			var secondPart:String = char.substring(position, char.length);
			return (firstPart + value + secondPart);
		}
		
		//替换指定位置字符;
		public static function replaceAt(char:String, value:String, beginIndex:int, endIndex:int):String 
		{
			beginIndex = Math.max(beginIndex, 0);			
			endIndex = Math.min(endIndex, char.length);
			var firstPart:String = char.substr(0, beginIndex);
			var secondPart:String = char.substr(endIndex, char.length);
			return (firstPart + value + secondPart);
		}
		
		//删除指定位置字符;
		public static function removeAt(char:String, beginIndex:int, endIndex:int):String
		{
			return StringUtility.replaceAt(char, "", beginIndex, endIndex);
		}
		
		//修复双换行符;
		public static function fixNewlines(char:String):String 
		{
			return char.replace(/\r\n/gm, "\n");
		}
		
		// 替换字符串		
		public static function substitute(str:String, ... rest):String
		{
			if (str == null) return '';
			
			// Replace all of the parameters in the msg string.
			var len:uint = rest.length;
			var args:Array;
			if (len == 1 && rest[0] is Array)
			{
				args = rest[0] as Array;
				len = args.length;
			}
			else
			{
				args = rest;
			}
			
			for (var i:int = 0; i < len; i++)
			{
				str = str.replace(new RegExp("\\{"+i+"\\}", "g"), args[i]);
			}
			
			return str;
		}
	}
}